26 research outputs found
Recognizing Planar Laman Graphs
Laman graphs are the minimally rigid graphs in the plane. We present two algorithms for recognizing planar Laman graphs. A simple algorithm with running time O(n^(3/2)) and a more complicated algorithm with running time O(n log^3 n) based on involved planar network flow algorithms. Both improve upon the previously fastest algorithm for general graphs by Gabow and Westermann [Algorithmica, 7(5-6):465 - 497, 1992] with running time O(n sqrt{n log n}).
To solve this problem we introduce two algorithms (with the running times stated above) that check whether for a directed planar graph G, disjoint sets S, T subseteq V(G), and a fixed k the following connectivity condition holds: for each vertex s in S there are k directed paths from s to T pairwise having only vertex s in common. This variant of connectivity seems interesting on its own
Edge-Orders
Canonical orderings and their relatives such as st-numberings have been used
as a key tool in algorithmic graph theory for the last decades. Recently, a
unifying concept behind all these orders has been shown: they can be described
by a graph decomposition into parts that have a prescribed vertex-connectivity.
Despite extensive interest in canonical orderings, no analogue of this
unifying concept is known for edge-connectivity. In this paper, we establish
such a concept named edge-orders and show how to compute (1,1)-edge-orders of
2-edge-connected graphs as well as (2,1)-edge-orders of 3-edge-connected graphs
in linear time, respectively. While the former can be seen as the edge-variants
of st-numberings, the latter are the edge-variants of Mondshein sequences and
non-separating ear decompositions. The methods that we use for obtaining such
edge-orders differ considerably in almost all details from the ones used for
their vertex-counterparts, as different graph-theoretic constructions are used
in the inductive proof and standard reductions from edge- to
vertex-connectivity are bound to fail.
As a first application, we consider the famous Edge-Independent Spanning Tree
Conjecture, which asserts that every k-edge-connected graph contains k rooted
spanning trees that are pairwise edge-independent. We illustrate the impact of
the above edge-orders by deducing algorithms that construct 2- and 3-edge
independent spanning trees of 2- and 3-edge-connected graphs, the latter of
which improves the best known running time from O(n^2) to linear time
Weakly and Strongly Fan-Planar Graphs
We study two notions of fan-planarity introduced by (Cheong et al., GD22),
called weak and strong fan-planarity that separate two non-equivalent
definitions of fan-planarity in the literature. We prove that not every weakly
fan-planar graph is strongly fan-planar, while the density upper bound for both
families is the same.Comment: Appears in the Proceedings of the 31st International Symposium on
Graph Drawing and Network Visualization (GD 2023
On Romeo and Juliet Problems: Minimizing Distance-to-Sight
We introduce a variant of the watchman route problem, which we call the quickest pair-visibility problem. Given two persons standing at points s and t in a simple polygon P with no holes, we want to minimize the distance these persons travel in order to see each other in P. We solve two variants of this problem, one minimizing the longer distance the two persons travel (min-max) and one minimizing the total travel distance (min-sum), optimally in linear time. We also consider a query version of this problem for the min-max variant. We can preprocess a simple n-gon in linear time so that the minimum of the longer distance the two persons travel can be computed in O(log^2 n) time for any two query positions where the two persons lie
Efficient Fréchet distance queries for segments
We study the problem of constructing a data structure that can store a two-dimensional polygonal curve P, such that for any query segment ab one can efficiently compute the FrĂ©chet distance between P and ab. First we present a data structure of size O(n log n) that can compute the FrĂ©chet distance between P and a horizontal query segment ab in O(log n) time, where n is the number of vertices of P. In comparison to prior work, this significantly reduces the required space. We extend the type of queries allowed, as we allow a query to be a horizontal segment ab together with two points s, t â P (not necessarily vertices), and ask for the FrĂ©chet distance between ab and the curve of P in between s and t. Using O(n log2 n) storage, such queries take O(log3 n) time, simplifying and significantly improving previous results. We then generalize our results to query segments of arbitrary orientation. We present an O(nk3+Ï” + n2) size data structure, where k â [1, n] is a parameter the user can choose, and Ï” > 0 is an arbitrarily small constant, such that given any segment ab and two points s, t â P we can compute the FrĂ©chet distance between ab and the curve of P in between s and t in O((n/k) log2 n + log4 n) time. This is the first result that allows efficient exact FrĂ©chet distance queries for arbitrarily oriented segments. We also present two applications of our data structure. First, we show that our data structure allows us to compute a local ÎŽ-simplification (with respect to the FrĂ©chet distance) of a polygonal curve in O(n5/2+Ï”) time, improving a previous O(n3) time algorithm. Second, we show that we can efficiently find a translation of an arbitrary query segment ab that minimizes the FrĂ©chet distance with respect to a subcurve of P